# def has_three_consecutive_equals(lst):  
#     # 遍历列表，检查连续三个元素是否相等  
#     for i in range(len(lst) - 2):  
#         if lst[i] == lst[i + 1] == lst[i + 2]:  
#             return True  
#     return False 

# def question1():
#     chepai = [0]*6

#     count = 0
#     for i in range(16):
#         for j in range(16):
#             for k in range(16): 

#                 for p in range(10):
#                     for q in range(10):
#                         for r in range(10):

#                             chepai[0] = i
#                             chepai[1] = j
#                             chepai[2] = k

#                             chepai[3] = p
#                             chepai[4] = q
#                             chepai[5] = r

#                             if not has_three_consecutive_equals(chepai):
#                                 count = count + 1
                                
#     return count



"""def binsearch(arr, n):
    left = 0
    right = len(arr) - 1

    while left <= right:
        mid = (left + right) // 2

        if arr[mid] == n:
            return mid
        elif arr[mid] < n:
            left = mid + 1
        else:
            right = mid - 1

    return None


class Stack:
    def __init__(self):
        self.items = []  # 初始化一个空列表来存储栈的元素

    def is_empty(self):
        return len(self.items) == 0  # 检查列表是否为空
    
    def peek(self):
        if not self.is_empty():
            return self.items[-1]  # 返回栈顶元素，但不做删除
        else:
            return None  # 或者抛出异常，取决于你的设计

    def pop(self):
        if not self.is_empty():
            return self.items.pop()  # 弹出并返回栈顶元素
        else:
            return None  # 或者抛出异常
    
    def push(self, n):
        self.items.append(n)  # 将元素添加到栈顶


def fac(n, star_dict=None):
    # 如果字典是 None，就在函数内部创建一个新的字典，并在递归调用中传递它
    if star_dict is None:
        star_dict = {0: 1, 1: 1}
    
    # 检查 n 是否已经在字典中
    if n in star_dict:
        return star_dict[n]
    
    # 计算 n 的斐波那契数，并将其存储在字典中
    star_dict[n] = fac(n - 1, star_dict) + fac(n - 2, star_dict)
    
    # 返回计算结果
    return star_dict[n]


def generate_combinations(s):
    # 辅助函数，用于递归生成组合
    def combine(prefix, suffix, results):
        # 如果后缀为空，则只添加前缀到结果中（非空的情况）
        if not suffix:
            if prefix:
                results.append(prefix)
        else:
            # 对后缀的第一个字符进行两种选择：包含或不包含在前缀中
            # 不包含的情况，直接递归处理剩余的后缀
            combine(prefix, suffix[1:], results)
            # 包含的情况，将当前字符加到前缀中，并递归处理剩余的后缀
            combine(prefix + suffix[0], suffix[1:], results)

    # 初始化结果列表
    results = []
    # 调用辅助函数开始组合
    combine("", s, results)
    # 返回所有组合
    return results

# 测试函数
s = "abc"
combinations = generate_combinations(s)
print(combinations)
"""


